home *** CD-ROM | disk | FTP | other *** search
/ Aminet 2 / Aminet AMIGA CDROM (1994)(Walnut Creek)[Feb 1994][W.O. 44790-1].iso / Aminet / util / gnu / groff_src.lha / Groff-1.07 / xditview / xditview.c < prev    next >
C/C++ Source or Header  |  1992-10-01  |  15KB  |  588 lines
  1. /*
  2.  * Copyright 1991 Massachusetts Institute of Technology
  3.  *
  4.  * Permission to use, copy, modify, distribute, and sell this software and its
  5.  * documentation for any purpose is hereby granted without fee, provided that
  6.  * the above copyright notice appear in all copies and that both that
  7.  * copyright notice and this permission notice appear in supporting
  8.  * documentation, and that the name of M.I.T. not be used in advertising or
  9.  * publicity pertaining to distribution of the software without specific,
  10.  * written prior permission.  M.I.T. makes no representations about the
  11.  * suitability of this software for any purpose.  It is provided "as is"
  12.  * without express or implied warranty.
  13.  *
  14.  * M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
  15.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T.
  16.  * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  17.  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  18.  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  19.  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  20.  *
  21.  */
  22. /*
  23.  * xditview -- 
  24.  *
  25.  *   Display ditroff output in an X window
  26.  */
  27.  
  28. #ifndef SABER
  29. #ifndef lint
  30. static char rcsid[] = "$XConsortium: xditview.c,v 1.17 89/12/10 17:05:08 rws Exp $";
  31. #endif /* lint */
  32. #endif /* SABER */
  33.  
  34. #include <X11/Xatom.h>
  35. #include <X11/Xlib.h>
  36. #include <X11/Intrinsic.h>
  37. #include <X11/StringDefs.h>
  38. #include <X11/Shell.h>
  39. #include <X11/Xaw/Paned.h>
  40. #include <X11/Xaw/Viewport.h>
  41. #include <X11/Xaw/Box.h>
  42. #include <X11/Xaw/Command.h>
  43. #include <X11/Xaw/Dialog.h>
  44. #include <X11/Xaw/Label.h>
  45. #include <X11/Xaw/SimpleMenu.h>
  46. #include <X11/Xaw/SmeBSB.h>
  47.  
  48. #include <signal.h>
  49.  
  50. #include "Dvi.h"
  51.  
  52. #include "xdit.bm"
  53. #include "xdit_mask.bm"
  54. #include "stdio.h"
  55.  
  56. extern FILE *popen();
  57. extern void exit();
  58.  
  59. static struct app_resources {
  60.     char *print_command;
  61.     char *filename;
  62. } app_resources;
  63.  
  64. #define offset(field) XtOffset(struct app_resources *, field)
  65.  
  66. /* Application resources. */
  67.  
  68. static XtResource resources[] = {
  69.   {"printCommand", "PrintCommand", XtRString, sizeof(char*),
  70.        offset(print_command), XtRString, NULL},
  71.   {"filename", "Filename", XtRString, sizeof(char*),
  72.        offset(filename), XtRString, NULL},
  73. };
  74.  
  75. #undef offset
  76.  
  77. /* Command line options table.  Only resources are entered here...there is a
  78.    pass over the remaining options after XtParseCommand is let loose. */
  79.  
  80. static XrmOptionDescRec options[] = {
  81. {"-page",        "*dvi.pageNumber",        XrmoptionSepArg,    NULL},
  82. {"-backingStore",   "*dvi.backingStore",    XrmoptionSepArg,    NULL},
  83. {"-resolution",        "*dvi.resolution",      XrmoptionSepArg,    NULL},
  84. {"-printCommand",   ".printCommand",        XrmoptionSepArg,    NULL},
  85. {"-filename",       ".filename",            XrmoptionSepArg,    NULL},
  86. {"-noPolyText",        "*dvi.noPolyText",        XrmoptionNoArg,    "TRUE"},
  87. };
  88.  
  89. static char current_print_command[1024];
  90.  
  91. static char    current_file_name[1024];
  92. static FILE    *current_file;
  93.  
  94. /*
  95.  * Report the syntax for calling xditview.
  96.  */
  97.  
  98. static
  99. Syntax(call)
  100.     char *call;
  101. {
  102.     (void) printf ("Usage: %s [-fg <color>] [-bg <color>]\n", call);
  103.     (void) printf ("       [-bd <color>] [-bw <pixels>] [-help]\n");
  104.     (void) printf ("       [-display displayname] [-geometry geom]\n");
  105.     (void) printf ("       [-page <page-number>] [-backing <backing-store>]\n");
  106.     (void) printf ("       [-resolution <res>] [-print <command>]\n");
  107.     (void) printf ("       [-filename <file>] [filename]\n\n");
  108.     exit(1);
  109. }
  110.  
  111. static void    NewFile (), SetPageNumber ();
  112. static Widget    toplevel, paned, viewport, dvi;
  113. static Widget    page;
  114. static Widget    simpleMenu;
  115.  
  116. static void    NextPage(), PreviousPage(), SelectPage(), OpenFile(), Quit();
  117. static void    Print();
  118.  
  119. static struct menuEntry {
  120.     char    *name;
  121.     void    (*function)();
  122. } menuEntries[] = {
  123.     "nextPage",        NextPage,
  124.     "previousPage", PreviousPage,
  125.     "selectPage",   SelectPage,
  126.     "print",        Print,
  127.     "openFile",        OpenFile,
  128.     "quit",        Quit,
  129. };
  130.  
  131. static void    NextPageAction(), PreviousPageAction(), SelectPageAction();
  132. static void    OpenFileAction(), QuitAction();
  133. static void    AcceptAction(), CancelAction();
  134. static void    PrintAction();
  135. static void    RerasterizeAction();
  136.  
  137. XtActionsRec xditview_actions[] = {
  138.     "NextPage",        NextPageAction,
  139.     "PreviousPage", PreviousPageAction,
  140.     "SelectPage",   SelectPageAction,
  141.     "Print",        PrintAction,
  142.     "OpenFile",        OpenFileAction,
  143.     "Rerasterize",  RerasterizeAction,
  144.     "Quit",        QuitAction,
  145.     "Accept",        AcceptAction,
  146.     "Cancel",        CancelAction,
  147. };
  148.  
  149. #define MenuNextPage        0
  150. #define MenuPreviousPage    1
  151. #define MenuSelectPage        2
  152. #define MenuPrint        3
  153. #define MenuOpenFile        4
  154. #define    MenuQuit        5
  155.  
  156. static char    pageLabel[256] = "Page <none>";
  157.  
  158. void main(argc, argv)
  159.     int argc;
  160.     char **argv;
  161. {
  162.     char        *file_name = 0;
  163.     int            i;
  164.     static Arg        labelArgs[] = {
  165.             {XtNlabel, (XtArgVal) pageLabel},
  166.     };
  167.     Arg            topLevelArgs[2];
  168.     Widget          entry;
  169.     Arg            pageNumberArgs[1];
  170.     int            page_number;
  171.  
  172.     toplevel = XtInitialize("main", "GXditview",
  173.                 options, XtNumber (options),
  174.                  &argc, argv);
  175.     if (argc > 2)
  176.     Syntax(argv[0]);
  177.  
  178.     XtGetApplicationResources(toplevel, (XtPointer)&app_resources,
  179.                   resources, XtNumber(resources),
  180.                   NULL, (Cardinal) 0);
  181.     if (app_resources.print_command)
  182.     strcpy(current_print_command, app_resources.print_command);
  183.  
  184.     XtAppAddActions(XtWidgetToApplicationContext(toplevel),
  185.             xditview_actions, XtNumber (xditview_actions));
  186.  
  187.     XtSetArg (topLevelArgs[0], XtNiconPixmap,
  188.           XCreateBitmapFromData (XtDisplay (toplevel),
  189.                      XtScreen(toplevel)->root,
  190.                      xdit_bits, xdit_width, xdit_height));
  191.                     
  192.     XtSetArg (topLevelArgs[1], XtNiconMask,
  193.           XCreateBitmapFromData (XtDisplay (toplevel),
  194.                      XtScreen(toplevel)->root,
  195.                      xdit_mask_bits, 
  196.                      xdit_mask_width, xdit_mask_height));
  197.     XtSetValues (toplevel, topLevelArgs, 2);
  198.     if (argc > 1)
  199.     file_name = argv[1];
  200.  
  201.     /*
  202.      * create the menu and insert the entries
  203.      */
  204.     simpleMenu = XtCreatePopupShell ("menu", simpleMenuWidgetClass, toplevel,
  205.                     NULL, 0);
  206.     for (i = 0; i < XtNumber (menuEntries); i++) {
  207.     entry = XtCreateManagedWidget(menuEntries[i].name, 
  208.                       smeBSBObjectClass, simpleMenu,
  209.                       NULL, (Cardinal) 0);
  210.     XtAddCallback(entry, XtNcallback, menuEntries[i].function, NULL);
  211.     }
  212.  
  213.     paned = XtCreateManagedWidget("paned", panedWidgetClass, toplevel,
  214.                     NULL, (Cardinal) 0);
  215.     viewport = XtCreateManagedWidget("viewport", viewportWidgetClass, paned,
  216.                      NULL, (Cardinal) 0);
  217.     dvi = XtCreateManagedWidget ("dvi", dviWidgetClass, viewport, NULL, 0);
  218.     page = XtCreateManagedWidget ("label", labelWidgetClass, paned,
  219.                     labelArgs, XtNumber (labelArgs));
  220.     XtSetArg (pageNumberArgs[0], XtNpageNumber, &page_number);
  221.     XtGetValues (dvi, pageNumberArgs, 1);
  222.     if (file_name)
  223.     NewFile (file_name);
  224.     /* NewFile modifies current_file_name, so do this here. */
  225.     if (app_resources.filename)
  226.     strcpy(current_file_name, app_resources.filename);
  227.     XtRealizeWidget (toplevel);
  228.     if (file_name)
  229.     SetPageNumber (page_number);
  230.     XtMainLoop();
  231. }
  232.  
  233. static void
  234. SetPageNumber (number)
  235. {
  236.     Arg    arg[2];
  237.     int    actual_number, last_page;
  238.  
  239.     XtSetArg (arg[0], XtNpageNumber, number);
  240.     XtSetValues (dvi, arg, 1);
  241.     XtSetArg (arg[0], XtNpageNumber, &actual_number);
  242.     XtSetArg (arg[1], XtNlastPageNumber, &last_page);
  243.     XtGetValues (dvi, arg, 2);
  244.     if (actual_number == 0)
  245.     sprintf (pageLabel, "Page <none>");
  246.     else if (last_page > 0)
  247.     sprintf (pageLabel, "Page %d of %d", actual_number, last_page);
  248.     else
  249.     sprintf (pageLabel, "Page %d", actual_number);
  250.     XtSetArg (arg[0], XtNlabel, pageLabel);
  251.     XtSetValues (page, arg, 1);
  252. }
  253.  
  254. static void
  255. SelectPageNumber (number_string)
  256. char    *number_string;
  257. {
  258.     SetPageNumber (atoi(number_string));
  259. }
  260.  
  261. static int hadFile = 0;
  262.  
  263. static void
  264. NewFile (name)
  265. char    *name;
  266. {
  267.     Arg        arg[2];
  268.     char    *n, *rindex ();
  269.     FILE    *new_file;
  270.     Boolean seek = 0;
  271.  
  272.     if (current_file) {
  273.     if (!strcmp (current_file_name, "-"))
  274.         ;
  275.     else if (current_file_name[0] == '|')
  276.         pclose (current_file);
  277.     else
  278.         fclose (current_file);
  279.     }
  280.     if (!strcmp (name, "-"))
  281.     new_file = stdin;
  282.     else if (name[0] == '|')
  283.     new_file = popen (name+1, "r");
  284.     else {
  285.     new_file = fopen (name, "r");
  286.     seek = 1;
  287.     }
  288.     if (!new_file) {
  289.     /* XXX display error message */
  290.     return;
  291.     }
  292.     XtSetArg (arg[0], XtNfile, new_file);
  293.     XtSetArg (arg[1], XtNseek, seek);
  294.     XtSetValues (dvi, arg, 2);
  295.     if (hadFile || name[0] != '-' || name[1] != '\0') {
  296.     XtSetArg (arg[0], XtNtitle, name);
  297.     if (name[0] != '/' && (n = rindex (name, '/')))
  298.         n = n + 1;
  299.     else
  300.         n = name;
  301.     XtSetArg (arg[1], XtNiconName, n);
  302.     XtSetValues (toplevel, arg, 2);
  303.     }
  304.     hadFile = 1;
  305.     SelectPageNumber ("1");
  306.     strcpy (current_file_name, name);
  307.     current_file = new_file;
  308. }
  309.  
  310. static char fileBuf[1024];
  311.  
  312. ResetMenuEntry (entry)
  313.     Widget  entry;
  314. {
  315.     Arg    arg[1];
  316.  
  317.     XtSetArg (arg[0], XtNpopupOnEntry, entry);
  318.     XtSetValues (XtParent(entry) , arg, (Cardinal) 1);
  319. }
  320.  
  321. /*ARGSUSED*/
  322.  
  323. static void
  324. NextPage (entry, name, data)
  325.     Widget  entry;
  326.     caddr_t name, data;
  327. {
  328.     NextPageAction();
  329.     ResetMenuEntry (entry);
  330. }
  331.  
  332. static void
  333. NextPageAction ()
  334. {
  335.     Arg    args[1];
  336.     int    number;
  337.  
  338.     XtSetArg (args[0], XtNpageNumber, &number);
  339.     XtGetValues (dvi, args, 1);
  340.     SetPageNumber (number+1);
  341. }
  342.  
  343. /*ARGSUSED*/
  344.  
  345. static void
  346. PreviousPage (entry, name, data)
  347.     Widget  entry;
  348.     caddr_t name, data;
  349. {
  350.     PreviousPageAction ();
  351.     ResetMenuEntry (entry);
  352. }
  353.  
  354. static void
  355. PreviousPageAction ()
  356. {
  357.     Arg    args[1];
  358.     int    number;
  359.  
  360.     XtSetArg (args[0], XtNpageNumber, &number);
  361.     XtGetValues (dvi, args, 1);
  362.     SetPageNumber (number-1);
  363. }
  364.  
  365. /* ARGSUSED */
  366.  
  367. static void
  368. SelectPage (entry, name, data)
  369.     Widget  entry;
  370.     caddr_t name, data;
  371. {
  372.     SelectPageAction ();
  373.     ResetMenuEntry (entry);
  374. }
  375.  
  376. static void
  377. SelectPageAction ()
  378. {
  379.     MakePrompt (toplevel, "Page number", SelectPageNumber, "");
  380. }
  381.  
  382.  
  383. static void
  384. DoPrint (name)
  385.     char *name;
  386. {
  387.     FILE *print_file;
  388. #ifdef SIGNALRETURNSINT
  389.     int (*handler)();
  390. #else
  391.     void (*handler)();
  392. #endif
  393.     /* Avoid dieing because of an invalid command. */
  394.     handler = signal(SIGPIPE, SIG_IGN);
  395.  
  396.     print_file = popen(name, "w");
  397.     if (!print_file)
  398.     /* XXX print error message */
  399.     return;
  400.     DviSaveToFile(dvi, print_file);
  401.     pclose(print_file);
  402.     signal(SIGPIPE, handler);
  403.     strcpy(current_print_command, name);
  404. }
  405.  
  406. static void
  407. RerasterizeAction()
  408. {
  409.     Arg    args[1];
  410.     int    number;
  411.  
  412.     if (current_file_name[0] == 0) {
  413.     /* XXX display an error message */
  414.     return;
  415.     } 
  416.     XtSetArg (args[0], XtNpageNumber, &number);
  417.     XtGetValues (dvi, args, 1);
  418.     NewFile(current_file_name);
  419.     SetPageNumber (number);
  420. }
  421.  
  422. /* ARGSUSED */
  423.  
  424. static void
  425. Print (entry, name, data)
  426.     Widget  entry;
  427.     caddr_t name, data;
  428. {
  429.     PrintAction ();
  430.     ResetMenuEntry (entry);
  431. }
  432.  
  433. static void
  434. PrintAction ()
  435. {
  436.     if (current_print_command[0])
  437.     strcpy (fileBuf, current_print_command);
  438.     else
  439.     fileBuf[0] = '\0';
  440.     MakePrompt (toplevel, "Print command:", DoPrint, fileBuf);
  441. }
  442.  
  443.  
  444. /* ARGSUSED */
  445.  
  446. static void
  447. OpenFile (entry, name, data)
  448.     Widget  entry;
  449.     caddr_t name, data;
  450. {
  451.     OpenFileAction ();
  452.     ResetMenuEntry (entry);
  453. }
  454.  
  455. static void
  456. OpenFileAction ()
  457. {
  458.     if (current_file_name[0])
  459.     strcpy (fileBuf, current_file_name);
  460.     else
  461.     fileBuf[0] = '\0';
  462.     MakePrompt (toplevel, "File to open:", NewFile, fileBuf);
  463. }
  464.  
  465. /* ARGSUSED */
  466.  
  467. static void
  468. Quit (entry, closure, data)
  469.     Widget  entry;
  470.     caddr_t closure, data;
  471. {
  472.     QuitAction ();
  473. }
  474.  
  475. static void
  476. QuitAction ()
  477. {
  478.     exit (0);
  479. }
  480.  
  481. Widget    promptShell, promptDialog;
  482. void    (*promptfunction)();
  483.  
  484. /* ARGSUSED */
  485. static
  486. void CancelAction (widget, event, params, num_params)
  487.     Widget    widget;
  488.     XEvent    *event;
  489.     String    *params;
  490.     Cardinal    *num_params;
  491. {
  492.     if (promptShell) {
  493.     XtSetKeyboardFocus(toplevel, (Widget) None);
  494.     XtDestroyWidget(promptShell);
  495.     promptShell = (Widget) 0;
  496.     }
  497. }
  498.  
  499. static
  500. void AcceptAction (widget, event, params, num_params)
  501.     Widget    widget;
  502.     XEvent    *event;
  503.     String    *params;
  504.     Cardinal    *num_params;
  505. {
  506.     (*promptfunction)(XawDialogGetValueString(promptDialog));
  507.     CancelAction (widget, event, params, num_params);
  508. }
  509.  
  510. MakePrompt(centerw, prompt, func, def)
  511. Widget    centerw;
  512. char *prompt;
  513. void (*func)();
  514. char    *def;
  515. {
  516.     static Arg dialogArgs[] = {
  517.     {XtNlabel, NULL},
  518.     {XtNvalue, NULL},
  519.     };
  520.     Arg valueArgs[1];
  521.     Arg centerArgs[2];
  522.     Position    source_x, source_y;
  523.     Position    dest_x, dest_y;
  524.     Dimension center_width, center_height;
  525.     Dimension prompt_width, prompt_height;
  526.     Widget  valueWidget;
  527.     
  528.     CancelAction ((Widget)NULL, (XEvent *) 0, (String *) 0, (Cardinal *) 0);
  529.     promptShell = XtCreatePopupShell ("promptShell", transientShellWidgetClass,
  530.                       toplevel, NULL, (Cardinal) 0);
  531.     dialogArgs[0].value = (XtArgVal)prompt;
  532.     dialogArgs[1].value = (XtArgVal)def;
  533.     promptDialog = XtCreateManagedWidget( "promptDialog", dialogWidgetClass,
  534.             promptShell, dialogArgs, XtNumber (dialogArgs));
  535.     XawDialogAddButton(promptDialog, "accept", NULL, (caddr_t) 0);
  536.     XawDialogAddButton(promptDialog, "cancel", NULL, (caddr_t) 0);
  537.     valueWidget = XtNameToWidget (promptDialog, "value");
  538.     if (valueWidget) {
  539.         XtSetArg (valueArgs[0], XtNresizable, TRUE);
  540.         XtSetValues (valueWidget, valueArgs, 1);
  541.     /*
  542.      * as resizable isn't set until just above, the
  543.      * default value will be displayed incorrectly.
  544.      * rectify the situation by resetting the values
  545.      */
  546.         XtSetValues (promptDialog, dialogArgs, XtNumber (dialogArgs));
  547.     }
  548.     XtSetKeyboardFocus (promptDialog, valueWidget);
  549.     XtSetKeyboardFocus (toplevel, valueWidget);
  550.     XtRealizeWidget (promptShell);
  551.     /*
  552.      * place the widget in the center of the "parent"
  553.      */
  554.     XtSetArg (centerArgs[0], XtNwidth, ¢er_width);
  555.     XtSetArg (centerArgs[1], XtNheight, ¢er_height);
  556.     XtGetValues (centerw, centerArgs, 2);
  557.     XtSetArg (centerArgs[0], XtNwidth, &prompt_width);
  558.     XtSetArg (centerArgs[1], XtNheight, &prompt_height);
  559.     XtGetValues (promptShell, centerArgs, 2);
  560.     source_x = (center_width - prompt_width) / 2;
  561.     source_y = (center_height - prompt_height) / 3;
  562.     XtTranslateCoords (centerw, source_x, source_y, &dest_x, &dest_y);
  563.     XtSetArg (centerArgs[0], XtNx, dest_x);
  564.     XtSetArg (centerArgs[1], XtNy, dest_y);
  565.     XtSetValues (promptShell, centerArgs, 2);
  566.     XtMapWidget(promptShell);
  567.     promptfunction = func;
  568. }
  569.  
  570. /* For DviChar.c */
  571.  
  572. char *xmalloc(n)
  573.     int n;
  574. {
  575.     return XtMalloc(n);
  576. }
  577.  
  578. /*
  579. Local Variables:
  580. c-indent-level: 4
  581. c-continued-statement-offset: 4
  582. c-brace-offset: -4
  583. c-argdecl-indent: 4
  584. c-label-offset: -4
  585. c-tab-always-indent: nil
  586. End:
  587. */
  588.